FXLOG

// winit 的 Wayland 實現
pub fn set_visible(&self, _visible: bool) {
    // Not possible on Wayland.
}

// gdk/wayland/gdkwindow-wayland.c
static void gdk_wayland_window_hide(GdkWindow *window) {
    GdkWindowImplWayland *impl = GDK_WINDOW_IMPL_WAYLAND(window->impl);
    
    wl_surface_attach(impl->display_server.wl_surface, NULL, 0, 0);
    wl_surface_commit(impl->display_server.wl_surface);
    _gdk_window_clear_update_area(window);
}

// WaylandToplevelWindow::Hide()
void WaylandToplevelWindow::Hide() {
    shell_toplevel_.reset();  // 銷毀 xdg_toplevel
    connection()->buffer_manager_host()->ResetSurfaceContents(root_surface());
}

// WaylandToplevelWindow::Show()
void WaylandToplevelWindow::Show(bool inactive) {
    if (!CreateShellToplevel()) { ... }  // 重新創建 xdg_toplevel
}

┌────────────────────────────┐
│                    Rustle (應用層)                     │
├────────────────────────────┤
│                    iced (GUI 框架)                     │
├────────────────────────────┤  
│                 iced_winit (窗口管理)                  │
├────────────────────────────┤
│                    winit (窗口抽象)                    │
├────────────────────────────┤  
│         smithay-client-toolkit (Wayland 封裝)          │
├────────────────────────────┤
│              wayland-client (協議綁定)                 │
├────────────────────────────┤
│                  Wayland Compositor                    │
└────────────────────────────┘

pub fn set_visible(&self, visible: bool) {
    // 根據 XDG Shell 協議：
    // - "Attaching a null buffer to a toplevel unmaps the surface."
    // - "The client can re-map the toplevel by performing a commit without any
    //    buffer attached, waiting for a configure event and handling it as usual."

    let surface = self.window.wl_surface();

    if visible {
        {
            let mut state = self.window_state.lock().unwrap();
            state.set_visible(true);
            // 重置 frame callback 狀態，打破死鎖
            state.frame_callback_reset();
        }

        surface.commit();
        self.request_redraw();
    } else {
        self.window_state.lock().unwrap().set_visible(false);
        
        // 清空待處理的 redraw 請求
        self.window_requests.redraw_requested.store(false, Ordering::Relaxed);

        // 按協議 unmap：attach(NULL) + commit
        surface.attach(None, 0, 0);
        surface.commit();
    }
}

pub enum Action {
    // ...existing actions...
    
    /// 設置窗口的可見性。
    SetVisible(Id, bool),
}

/// 設置窗口的可見性。
pub fn set_visible<T>(id: Id, visible: bool) -> Task<T> {
    task::effect(crate::Action::Window(Action::SetVisible(id, visible)))
}

window::Action::SetVisible(id, visible) => {
    if let Some(window) = window_manager.get_mut(id) {
        window.raw.set_visible(visible);
    }
}

// Hyprland 崩潰堆棧
CWindow::create(CXDGSurfaceResource)
CWLSurface::assign
CWLSurface::init  // 崩潰點

┌───────────────────────────┐
│  wgpu 等待 frame callback 才能提交 buffer            │
│                        ↓                            │
│  compositor 等待 buffer 才能發送 frame callback      │
│                        ↓                            │
│                       死鎖！                         │
└───────────────────────────┘

state.frame_callback_reset();  // 重置為 None，允許立即重繪

// 1. refresh_frame() 中檢查 visible
pub fn refresh_frame(&mut self) -> bool {
    if !self.visible {
        return false;  // 隱藏時不刷新裝飾
    }
    // ...
}

// 2. request_redraw() 中檢查 visible
pub fn request_redraw(&self) {
    if !self.window_state.lock().unwrap().visible() {
        return;  // 隱藏時不請求重繪
    }
    // ...
}

// 3. set_visible(false) 時清空 pending redraw
self.window_requests.redraw_requested.store(false, Ordering::Relaxed);

// 4. event loop 派發時檢查 visible
if !window.visible() {
    window_requests.get(window_id).unwrap().take_redraw_requested();
    return None;  // 不派發 RedrawRequested
}

隱藏窗口:
┌────────────────────────┐
│ 1. set_visible(false)                          │
│ 2. 設置 visible 狀態為 false                   │
│ 3. 清空 pending redraw 請求                    │
│ 4. wl_surface.attach(NULL, 0, 0)               │
│ 5. wl_surface.commit()                         │
│ → Surface 被 unmap，compositor 不再顯示它     │
└────────────────────────┘

顯示窗口:
┌────────────────────────┐
│ 1. set_visible(true)                           │
│ 2. 設置 visible 狀態為 true                    │
│ 3. 重置 frame_callback_state (打破死鎖)        │
│ 4. wl_surface.commit()                         │
│ 5. request_redraw()                            │
│ → 觸發重繪，wgpu attach buffer，窗口重新出現  │
└────────────────────────┘

// 在 iced 應用中
Message::ToggleWindow => {
    self.window_hidden = !self.window_hidden;
    let visible = !self.window_hidden;
    
    return iced::window::latest().and_then(move |id| {
        iced::window::set_visible(id, visible)
    });
}